/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 14785
 * Date: 2025-07-10
 * Time: 23:57
 */
import java.util.Arrays;
public class test {

    public static void func(){
// newArr和arr引用的是同一个数组
// 因此newArr修改空间中内容之后，arr也可以看到修改的结果
        int[] arr = {1,2,3,4,5,6};
        int[] newArr = arr;
        newArr[0] = 10;
        System.out.println("newArr: " + Arrays.toString(arr));
// 使用Arrays中copyOf方法完成数组的拷贝：
// copyOf方法在进行数组拷贝时，创建了一个新的数组
// arr和newArr引用的不是同一个数组
        arr[0] = 1;
        newArr = Arrays.copyOf(arr, arr.length);
        System.out.println("newArr: " + Arrays.toString(newArr));
// 因为arr修改其引用数组中内容时，对newArr没有任何影响
        arr[0] = 10;
        System.out.println("arr: " + Arrays.toString(arr));
        System.out.println("newArr: " + Arrays.toString(newArr));
// 拷贝某个范围.
        int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);
        System.out.println("newArr2: " + Arrays.toString(newArr2));
    }
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        System.out.println(binarySearch(arr, 6));
    }
    public static int binarySearch(int[] arr, int toFind) {
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {

//            可以看到, 针对一个长度为 10000 个元素的数组查找, 二分查找只需要循环 14 次就能完成查找. 随着数组元素个数
//            越多, 二分的优势就越大.
//            4.6 数组排序(冒泡排序)
//            给定一个数组, 让数组升序 (降序) 排序.
//                    算法思路
//            假设排升序：
//            1. 将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟下来后最大元素
//                    就在数组的末尾
//            2. 依次从上上述过程，直到数组中所有的元素都排列好

            int mid = (left + right) / 2;
            if (toFind < arr[mid]) {
// 去左侧区间找
                right = mid - 1;
            } else if (toFind > arr[mid]) {
// 去右侧区间找
                left = mid + 1;
            } else {
// 相等, 说明找到了
                return mid;
            }
        }
// 循环结束, 说明没找到
        return -1;
    }
}

